1. Field of the Invention
The present invention generally relates to a method, system and program product for retrofitting collaborative components into existing software applications.
2. Related Art
It is often desirable to introduce collaborative features, such as instant-messaging and email, into the user interface of software applications (e.g., “contextual collaboration” is an approach that embeds new collaborative capabilities into familiar non-collaborative applications). Unfortunately, some applications are not amenable to revision or reconstruction. Retrofitting collaborative features into legacy systems, in-house/custom-built software, and mission-critical applications using conventional approaches may be too expensive, time-consuming, and risky to be worthwhile. Ideally, the retrofitting process should have as little impact on the application as possible, yet it must incorporate the desired set of collaborative features.
To date, retrofitting has occurred at three levels—the application level, the programming environment level, and the operating system level. Each level has its own set of options, strengths, weaknesses, and Computer Supported Cooperative Work (CSCW)-related examples for the application developer to consider. Retrofitting at the application level enables the developer to leverage any extensibility offered by the application's architecture. The chief benefit is that any collaborative features that are introduced will exist gracefully within the application. Ideally, the framework for extension would focus on the application-specific issues and insulate the developer from peripheral and low-level details of the operating environment around the application.
Examples include using application programming interfaces intended for third-parties to introduce new components, or creating a proxy service to intercept and change the standardized protocols for communication and presentation supported by the application (e.g. SmartPrinter, a registered trademark, uses a proxy leveraging the printing protocol used by all applications in their workplace to insert awareness information on printouts). However, the original architects of the applications cannot be expected to foresee every future contingency, and the available application programming interfaces and standard protocols may be limited or nonexistent.
Retrofitting can also be considered at the programming environment level: one may be able to exploit the runtime characteristics of the environment used to create the application—particularly the dynamic capabilities of the language for the component responsible for the user interface. Some programming language environments are flexible, and offer options for programs to modify themselves at runtime and dynamically load new modules, without requiring recompilation. The main benefit here is the potential to significantly customize the behavior of the application beyond the original design of the application. Other environments offer some flexibility in manipulating the language's runtime libraries for user interfaces and event handling, without rebuilding the entire application. For example, through a custom class loader, Flexible Java Mail Manager (JAMM) does runtime replacement of Java's single-user interface components with collaborative equivalents.
A problem with this approach is that not all programming environments have the needed flexibility. The application being retrofitted may be coded in a restrictive environment, and have requirements for strict control over runtime configuration that may deny modification access to certain runtime libraries. Also, if well-defined APIs are not available, it may be difficult to customize or introduce new behaviors into the application. For example, while it might be easy to replace the default label widget with a new one by replacing the widget library at runtime, specifying that only one particular label use the customized label might not be possible with this technique.
Another level to consider for retrofitting involves interfacing with the operating system to trap event calls, capture pixels on the screen, and hook into the boundary between the application and the operating system's services. This option essentially treats the application like a “black box.” However, there are a number of drawbacks to the operating system level approach. While the application becomes a “black box,” the developer must now focus on the intricacies of the operating system. The deep semantics and data structures of the application are also obscured; only events and visible elements of the user interface are discernable at the operating system level. Moreover, there may be interference from events and side-effects from other applications and services running in the operating system. Thus, intelligent analysis of these discernable events may be required for seemingly simple application operations. Each of these levels highlights a diverse array of examples and suggests desirable characteristics to help retrofitting.
In view of the foregoing, there exists a need for a method system and program product for retrofitting collaborative components into existing software applications. Specifically, a need exists for a system that can retrofit collaborative components into existing software applications without having to edit or change the original source code.